%     FASTENER DOCTOR - программа для лечения и конвертации крепежа
%     Copyright (C) 2018-2019  Михаил Козлов
%     Сайт проекта: <http://www.fastenerdoctor.ru/>
%     Адрес электронной почты для связи с разработчиком:
%     <doctor.fastener@gmail.com>
% 
%     Эта программа является свободным программным обеспечением: Вы можете
%     распространять ее и/или изменять, соблюдая условия Универсальной общественной
%     лицензии GNU, опубликованной Фондом свободного программного обеспечения,
%     либо редакции 3, либо (на Ваше усмотрение) любой редакции, выпущенной позже.
% 
%     Эта программа распространяется в надежде на то, что она окажется полезной,
%     но БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, включая даже подразумеваемую гарантию ТОВАРНОЙ ПРИГОДНОСТИ,
%     либо ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Ознакомьтесь с Универсальной общественной
%     лицензией GNU для получения более подробной информации.
% 
%     Вы должны были получить копию Универсальной общественной лицензии GNU
%     вместе с этой программой. Если Вы ее не получили, то перейдите по адресу:
%     <http://www.gnu.org/licenses/>.
% 
%     This program is free software: you can redistribute it and/or modify
%     it under the terms of the GNU General Public License as published by
%     the Free Software Foundation, either version 3 of the License, or
%     (at your option) any later version.
% 
%     This program is distributed in the hope that it will be useful,
%     but WITHOUT ANY WARRANTY; without even the implied warranty of
%     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
%     GNU General Public License for more details.
% 
%     You should have received a copy of the GNU General Public License
%     along with this program.  If not, see <https://www.gnu.org/licenses/>.

function DB_ELEMENTS = Create_DB_ELEMENTS(ELEMENTS)

% До обработки:

% ELEMENTS (карточки CTETRA, CPENTA, CHEXA) | .card | .ID | .Prop_ID | .N_nodes | .Nodes(N_nodes,1) |
% ELEMENTS (карточка CQUAD4) | .card | .ID | .Prop_ID | .G(4,1) | .THETA_MCID | .ZOFFS | .TFLAG | .T1 | .T2 | .T3 | .T4 | .Ori_type (CID | Angle) |
% ELEMENTS (карточка CQUAD8) | .card | .ID | .Prop_ID | .G(8,1) | .T1 | .T2 | .T3 | .T4 | .THETA_MCID | .ZOFFS | .TFLAG | .Ori_type (CID | Angle) |
% ELEMENTS (карточка CTRIA3) | .card | .ID | .Prop_ID | .G(3,1) | .THETA_MCID | .ZOFFS | .TFLAG | .T1 | .T2 | .T3 | .Ori_type (CID | Angle) |
% ELEMENTS (карточка CTRIA6) | .card | .ID | .Prop_ID | .G(6,1) | .THETA_MCID | .ZOFFS | .T1 | .T2 | .T3 | .TFLAG | .Ori_type (CID | Angle) |
% ELEMENTS (карточка  CBUSH) | .card | .ID | .Prop_ID | .GA | .GB | .GO | .X1 | .X2 | .X3 | .CID | .S | .OCID | .S1 | .S2 | .S3 |
% ELEMENTS (карточка   CROD) | .card | .ID | .Prop_ID | .G1 | .G2 |
% ELEMENTS (карточка   CBAR) | .card | .ID | .Prop_ID | .GA | .GB | .G0 | .X1 | .X2 | .X3 | .OFFT | .PA | .PB | .W1A | .W2A | .W3A | .W1B | .W2B | .W3B |
% ELEMENTS (карточка  CBEAM) | .card | .ID | .Prop_ID | .GA | .GB | .G0 | .X1 | .X2 | .X3 | .OFFT | .BIT | .PA | .PB | .W1A | .W2A | .W3A | .W1B | .W2B | .W3B | .SA | .SB |

% После обработки:

% DB_ELEMENTS (Tet | Wedge | Hex) | .type | .ID | .Prop_ID | .N_nodes | .Nodes(N_nodes,1) |
% DB_ELEMENTS (Quad | Tria)       | .type | .ID | .Prop_ID | .N_nodes | .Nodes(N_nodes,1) |
% DB_ELEMENTS (Bar)               | .type | .ID | .Prop_ID | .N_nodes | .Nodes(N_nodes,1) |


global ErrCode;

global Progress_Bar_Segments;
global Progress_Bar_Delay;
global Progress_Bar_Elm_Threshold;

global Orientation_Vector_zero_tolerance;

global DB_NODES;
global DB_COORD;
global DB_PSETS;

global AT_NODES;
global AT_COORD;
global AT_PSETS;

fprintf (1, 'Обработка элементов...                  ');

if (size(ELEMENTS,1) > Progress_Bar_Elm_Threshold)
    
    % Для вывода прогресса
    Time_segments = Progress_Bar_Segments;
    N_records = size(ELEMENTS,1);
    N_rec_segm = floor(N_records/Time_segments);
    Counter = 0;
    Counter_2 = 0;
    Written_count = 0;

end


DB_ELEMENTS = cell(size(ELEMENTS,1),1);

for i=1:size(ELEMENTS,1)
    
    switch upper(ELEMENTS{i}.card)
        
        case 'CBUSH'
            
            DB_ELEMENTS{i}.type = 'Bar';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = 2;
            DB_ELEMENTS{i}.Nodes = zeros(2,1);
            DB_ELEMENTS{i}.Nodes(1) = ELEMENTS{i}.GA;
            DB_ELEMENTS{i}.Nodes(2) = ELEMENTS{i}.GB;
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_CID_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.CID);
            if (ErrCode < 0)
                return;
            end
            
        case 'CROD'
            
            DB_ELEMENTS{i}.type = 'Bar';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = 2;
            DB_ELEMENTS{i}.Nodes = zeros(2,1);
            DB_ELEMENTS{i}.Nodes(1) = ELEMENTS{i}.G1;
            DB_ELEMENTS{i}.Nodes(2) = ELEMENTS{i}.G2;
            
        case 'CBAR'
            
            DB_ELEMENTS{i}.type = 'Bar';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = 2;
            DB_ELEMENTS{i}.Nodes = zeros(2,1);
            DB_ELEMENTS{i}.Nodes(1) = ELEMENTS{i}.GA;
            DB_ELEMENTS{i}.Nodes(2) = ELEMENTS{i}.GB;
                        
            if (~isempty(ELEMENTS{i}.G0))
                
                Ori_vector = DB_NODES{AT_NODES(ELEMENTS{i}.G0)}.Location - DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Location;
                
                ori_vec_norm = norm(Ori_vector);
                
                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации GA:G0 меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                    ErrCode = -1;
                    return;
                end
                
%                 Ori_vector = Ori_vector / ori_vec_norm;
                
            else
                
                Ori_vector = zeros(3,1);
                
                if (isempty(ELEMENTS{i}.X1))
                    Ori_vector(1) = 0;
                else
                    Ori_vector(1) = ELEMENTS{i}.X1;
                end
                
                if (isempty(ELEMENTS{i}.X2))
                    Ori_vector(2) = 0;
                else
                    Ori_vector(2) = ELEMENTS{i}.X2;
                end
                
                if (isempty(ELEMENTS{i}.X3))
                    Ori_vector(3) = 0;
                else
                    Ori_vector(3) = ELEMENTS{i}.X3;
                end
                
                if (isempty(ELEMENTS{i}.OFFT))
                    
                    % Система координат анализа ("Global")
                    Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;
                    
                    if (Coord_ID == 0)
                        
                        ori_vec_norm = norm(Ori_vector);

                        % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                        if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;
                        end
                        
%                         Ori_vector = Ori_vector / ori_vec_norm;
                        
                    else
                        Coord_Ind = AT_COORD(Coord_ID);
                        switch DB_COORD{Coord_Ind}.type
                            case 'Rectangular'
                                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                    ErrCode = -1;
                                    return;
                                end
                                Ori_vector = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                 Ori_vector = Ori_vector / norm(Ori_vector);
                            case 'Cylindrical'
                                Ori_vector = [Ori_vector(1)*cosd(Ori_vector(2)); Ori_vector(1)*sind(Ori_vector(2)); Ori_vector(3)];
                                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                    ErrCode = -1;
                                    return;
                                end
                                Ori_vector = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                 Ori_vector = Ori_vector / norm(Ori_vector);
                            otherwise
                                fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                        end
                    end
                    
                else
                    
                    switch upper(ELEMENTS{i}.OFFT(1))
                        
                        case 'G'
                            
                            % Система координат анализа ("Global")
                            Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;

                            if (Coord_ID == 0)
                                
                                ori_vec_norm = norm(Ori_vector);

                                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                    ErrCode = -1;
                                    return;
                                end
                                
%                                 Ori_vector = Ori_vector / ori_vec_norm;
                                
                            else
                                Coord_Ind = AT_COORD(Coord_ID);
                                switch DB_COORD{Coord_Ind}.type
                                    case 'Rectangular'
                                        % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                        if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                            ErrCode = -1;
                                            return;
                                        end
                                        Ori_vector = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                         Ori_vector = Ori_vector / norm(Ori_vector);
                                    case 'Cylindrical'
                                        Ori_vector = [Ori_vector(1)*cosd(Ori_vector(2)); Ori_vector(1)*sind(Ori_vector(2)); Ori_vector(3)];
                                        % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                        if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                            ErrCode = -1;
                                            return;
                                        end
                                        Ori_vector = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                         Ori_vector = Ori_vector / norm(Ori_vector);
                                    otherwise
                                        fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                        ErrCode = -1;
                                        return;
                                end
                            end
                            
                        case 'B'
                            
                            % Глобальная система координат ("Basic")
                            
                            ori_vec_norm = norm(Ori_vector);

                            % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                            if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                            end
                            
%                             Ori_vector = Ori_vector / ori_vec_norm;
                        
                        otherwise
                            
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.OFFT(1) !\n');
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;
                                
                    end
                    
                end
                
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_vector_Field_ID, DB_ELEMENTS{i}.ID, Ori_vector);
            if (ErrCode < 0)
                return;
            end
            
            if ((~isempty(ELEMENTS{i}.W1A)) || (~isempty(ELEMENTS{i}.W2A)) || (~isempty(ELEMENTS{i}.W3A)))
            
                Tmp_vector = zeros(3,1);

                if (isempty(ELEMENTS{i}.W1A))
                    Tmp_vector(1) = 0;
                else
                    Tmp_vector(1) = ELEMENTS{i}.W1A;
                end

                if (isempty(ELEMENTS{i}.W2A))
                    Tmp_vector(2) = 0;
                else
                    Tmp_vector(2) = ELEMENTS{i}.W2A;
                end

                if (isempty(ELEMENTS{i}.W3A))
                    Tmp_vector(3) = 0;
                else
                    Tmp_vector(3) = ELEMENTS{i}.W3A;
                end

                if (isempty(ELEMENTS{i}.OFFT))

                    % Система координат анализа ("Global")
                    Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;

                    if (Coord_ID == 0)
                        Offset_vector_A = Tmp_vector;
                    else
                        Coord_Ind = AT_COORD(Coord_ID);
                        switch DB_COORD{Coord_Ind}.type
                            case 'Rectangular'
                                Offset_vector_A = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            case 'Cylindrical'
                                Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                Offset_vector_A = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            otherwise
                                fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                        end
                    end

                else

                    switch upper(ELEMENTS{i}.OFFT(2))

                        case 'G'

                            % Система координат анализа ("Global")
                            Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;

                            if (Coord_ID == 0)
                                Offset_vector_A = Tmp_vector;
                            else
                                Coord_Ind = AT_COORD(Coord_ID);
                                switch DB_COORD{Coord_Ind}.type
                                    case 'Rectangular'
                                        Offset_vector_A = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    case 'Cylindrical'
                                        Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                        Offset_vector_A = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    otherwise
                                        fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                        ErrCode = -1;
                                        return;
                                end
                            end

                        case 'O'

                            % Система координат оффсета ("Offset")
                            
                            e_x = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Location - DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Location;
                            
                            ori_vec_norm = norm(e_x);
                            
                            % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                            if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации GA:GB меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                            end
                            
                            e_x = e_x / ori_vec_norm;
                            
                            e_z = cross(e_x, Ori_vector);
                            e_z = e_z / norm(e_z);
                            
                            e_y = cross(e_z, e_x);
                            e_y = e_y / norm(e_y);
                            
                            Offset_vector_A = [e_x, e_y, e_z]*Tmp_vector;
                            
                        otherwise
                            
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.OFFT(2) !\n');
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;

                    end

                end
                
            else
                
                Offset_vector_A = [];
            
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_vector_A_Field_ID, DB_ELEMENTS{i}.ID, Offset_vector_A);
            if (ErrCode < 0)
                return;
            end
            
            if ((~isempty(ELEMENTS{i}.W1B)) || (~isempty(ELEMENTS{i}.W2B)) || (~isempty(ELEMENTS{i}.W3B)))
            
                Tmp_vector = zeros(3,1);

                if (isempty(ELEMENTS{i}.W1B))
                    Tmp_vector(1) = 0;
                else
                    Tmp_vector(1) = ELEMENTS{i}.W1B;
                end

                if (isempty(ELEMENTS{i}.W2B))
                    Tmp_vector(2) = 0;
                else
                    Tmp_vector(2) = ELEMENTS{i}.W2B;
                end

                if (isempty(ELEMENTS{i}.W3B))
                    Tmp_vector(3) = 0;
                else
                    Tmp_vector(3) = ELEMENTS{i}.W3B;
                end

                if (isempty(ELEMENTS{i}.OFFT))

                    % Система координат анализа ("Global")
                    Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Analysis_CID;

                    if (Coord_ID == 0)
                        Offset_vector_B = Tmp_vector;
                    else
                        Coord_Ind = AT_COORD(Coord_ID);
                        switch DB_COORD{Coord_Ind}.type
                            case 'Rectangular'
                                Offset_vector_B = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            case 'Cylindrical'
                                Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                Offset_vector_B = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            otherwise
                                fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                        end
                    end

                else

                    switch upper(ELEMENTS{i}.OFFT(3))

                        case 'G'

                            % Система координат анализа ("Global")
                            Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Analysis_CID;

                            if (Coord_ID == 0)
                                Offset_vector_B = Tmp_vector;
                            else
                                Coord_Ind = AT_COORD(Coord_ID);
                                switch DB_COORD{Coord_Ind}.type
                                    case 'Rectangular'
                                        Offset_vector_B = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    case 'Cylindrical'
                                        Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                        Offset_vector_B = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    otherwise
                                        fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                        ErrCode = -1;
                                        return;
                                end
                            end

                        case 'O'

                            % Система координат оффсета ("Offset")

                            e_x = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Location - DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Location;
                            
                            ori_vec_norm = norm(e_x);
                            
                            % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                            if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации GA:GB меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                            end
                            
                            e_x = e_x / ori_vec_norm;
                            
                            e_z = cross(e_x, Ori_vector);
                            e_z = e_z / norm(e_z);
                            
                            e_y = cross(e_z, e_x);
                            e_y = e_y / norm(e_y);
                            
                            Offset_vector_B = [e_x, e_y, e_z]*Tmp_vector;
                            
                        otherwise
                            
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.OFFT(3) !\n');
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;

                    end

                end
                
            else
                
                Offset_vector_B = [];
            
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_vector_B_Field_ID, DB_ELEMENTS{i}.ID, Offset_vector_B);
            if (ErrCode < 0)
                return;
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Pinned_DOFs_A_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.PA);
            if (ErrCode < 0)
                return;
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Pinned_DOFs_B_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.PB);
            if (ErrCode < 0)
                return;
            end
            
        case 'CBEAM'
            
            DB_ELEMENTS{i}.type = 'Bar';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = 2;
            DB_ELEMENTS{i}.Nodes = zeros(2,1);
            DB_ELEMENTS{i}.Nodes(1) = ELEMENTS{i}.GA;
            DB_ELEMENTS{i}.Nodes(2) = ELEMENTS{i}.GB;
                        
            if (~isempty(ELEMENTS{i}.G0))
                
                Ori_vector = DB_NODES{AT_NODES(ELEMENTS{i}.G0)}.Location - DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Location;
                
                ori_vec_norm = norm(Ori_vector);
                
                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации GA:G0 меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                    ErrCode = -1;
                    return;
                end
                
%                 Ori_vector = Ori_vector / ori_vec_norm;
                
            else
                
                Ori_vector = zeros(3,1);
                
                if (isempty(ELEMENTS{i}.X1))
                    Ori_vector(1) = 0;
                else
                    Ori_vector(1) = ELEMENTS{i}.X1;
                end
                
                if (isempty(ELEMENTS{i}.X2))
                    Ori_vector(2) = 0;
                else
                    Ori_vector(2) = ELEMENTS{i}.X2;
                end
                
                if (isempty(ELEMENTS{i}.X3))
                    Ori_vector(3) = 0;
                else
                    Ori_vector(3) = ELEMENTS{i}.X3;
                end
                
                if (isempty(ELEMENTS{i}.OFFT))
                    
                    % Система координат анализа ("Global")
                    Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;
                    
                    if (Coord_ID == 0)
                        
                        ori_vec_norm = norm(Ori_vector);

                        % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                        if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;
                        end
                        
%                         Ori_vector = Ori_vector / ori_vec_norm;
                    else
                        Coord_Ind = AT_COORD(Coord_ID);
                        switch DB_COORD{Coord_Ind}.type
                            case 'Rectangular'
                                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                    ErrCode = -1;
                                    return;
                                end
                                Ori_vector = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                 Ori_vector = Ori_vector / norm(Ori_vector);
                            case 'Cylindrical'
                                Ori_vector = [Ori_vector(1)*cosd(Ori_vector(2)); Ori_vector(1)*sind(Ori_vector(2)); Ori_vector(3)];
                                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                    ErrCode = -1;
                                    return;
                                end
                                Ori_vector = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                 Ori_vector = Ori_vector / norm(Ori_vector);
                            otherwise
                                fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                        end
                    end
                    
                else
                    
                    switch upper(ELEMENTS{i}.OFFT(1))
                        
                        case 'G'
                            
                            % Система координат анализа ("Global")
                            Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;

                            if (Coord_ID == 0)
                                
                                ori_vec_norm = norm(Ori_vector);

                                % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                    fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                    fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                    ErrCode = -1;
                                    return;
                                end
                                
%                                 Ori_vector = Ori_vector / ori_vec_norm;
                            else
                                Coord_Ind = AT_COORD(Coord_ID);
                                switch DB_COORD{Coord_Ind}.type
                                    case 'Rectangular'
                                        % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                        if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                            ErrCode = -1;
                                            return;
                                        end
                                        Ori_vector = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                         Ori_vector = Ori_vector / norm(Ori_vector);
                                    case 'Cylindrical'
                                        Ori_vector = [Ori_vector(1)*cosd(Ori_vector(2)); Ori_vector(1)*sind(Ori_vector(2)); Ori_vector(3)];
                                        % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                                        if (norm(Ori_vector) < Orientation_Vector_zero_tolerance)
                                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                            ErrCode = -1;
                                            return;
                                        end
                                        Ori_vector = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Ori_vector;
%                                         Ori_vector = Ori_vector / norm(Ori_vector);
                                    otherwise
                                        fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                        ErrCode = -1;
                                        return;
                                end
                            end
                            
                        case 'B'
                            
                            % Глобальная система координат ("Basic")
                            
                            ori_vec_norm = norm(Ori_vector);

                            % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                            if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации V меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                            end
                            
%                             Ori_vector = Ori_vector / ori_vec_norm;
                            
                        otherwise
                            
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.OFFT(1) !\n');
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;
                        
                    end
                    
                end
                
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_vector_Field_ID, DB_ELEMENTS{i}.ID, Ori_vector);
            if (ErrCode < 0)
                return;
            end
            
            if ((~isempty(ELEMENTS{i}.W1A)) || (~isempty(ELEMENTS{i}.W2A)) || (~isempty(ELEMENTS{i}.W3A)))
            
                Tmp_vector = zeros(3,1);

                if (isempty(ELEMENTS{i}.W1A))
                    Tmp_vector(1) = 0;
                else
                    Tmp_vector(1) = ELEMENTS{i}.W1A;
                end

                if (isempty(ELEMENTS{i}.W2A))
                    Tmp_vector(2) = 0;
                else
                    Tmp_vector(2) = ELEMENTS{i}.W2A;
                end

                if (isempty(ELEMENTS{i}.W3A))
                    Tmp_vector(3) = 0;
                else
                    Tmp_vector(3) = ELEMENTS{i}.W3A;
                end

                if (isempty(ELEMENTS{i}.OFFT))

                    % Система координат анализа ("Global")
                    Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;

                    if (Coord_ID == 0)
                        Offset_vector_A = Tmp_vector;
                    else
                        Coord_Ind = AT_COORD(Coord_ID);
                        switch DB_COORD{Coord_Ind}.type
                            case 'Rectangular'
                                Offset_vector_A = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            case 'Cylindrical'
                                Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                Offset_vector_A = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            otherwise
                                fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                        end
                    end

                else

                    switch upper(ELEMENTS{i}.OFFT(2))

                        case 'G'

                            % Система координат анализа ("Global")
                            Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Analysis_CID;

                            if (Coord_ID == 0)
                                Offset_vector_A = Tmp_vector;
                            else
                                Coord_Ind = AT_COORD(Coord_ID);
                                switch DB_COORD{Coord_Ind}.type
                                    case 'Rectangular'
                                        Offset_vector_A = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    case 'Cylindrical'
                                        Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                        Offset_vector_A = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    otherwise
                                        fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                        ErrCode = -1;
                                        return;
                                end
                            end

                        case 'O'

                            % Система координат оффсета ("Offset")
                            
                            e_x = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Location - DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Location;
                            
                            ori_vec_norm = norm(e_x);
                            
                            % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                            if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации GA:GB меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                            end
                            
                            e_x = e_x / ori_vec_norm;
                            
                            e_z = cross(e_x, Ori_vector);
                            e_z = e_z / norm(e_z);
                            
                            e_y = cross(e_z, e_x);
                            e_y = e_y / norm(e_y);
                            
                            Offset_vector_A = [e_x, e_y, e_z]*Tmp_vector;
                            
                        otherwise
                            
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.OFFT(2) !\n');
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;

                    end

                end
                
            else
                
                Offset_vector_A = [];
            
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_vector_A_Field_ID, DB_ELEMENTS{i}.ID, Offset_vector_A);
            if (ErrCode < 0)
                return;
            end
            
            if ((~isempty(ELEMENTS{i}.W1B)) || (~isempty(ELEMENTS{i}.W2B)) || (~isempty(ELEMENTS{i}.W3B)))
            
                Tmp_vector = zeros(3,1);

                if (isempty(ELEMENTS{i}.W1B))
                    Tmp_vector(1) = 0;
                else
                    Tmp_vector(1) = ELEMENTS{i}.W1B;
                end

                if (isempty(ELEMENTS{i}.W2B))
                    Tmp_vector(2) = 0;
                else
                    Tmp_vector(2) = ELEMENTS{i}.W2B;
                end

                if (isempty(ELEMENTS{i}.W3B))
                    Tmp_vector(3) = 0;
                else
                    Tmp_vector(3) = ELEMENTS{i}.W3B;
                end

                if (isempty(ELEMENTS{i}.OFFT))

                    % Система координат анализа ("Global")
                    Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Analysis_CID;

                    if (Coord_ID == 0)
                        Offset_vector_B = Tmp_vector;
                    else
                        Coord_Ind = AT_COORD(Coord_ID);
                        switch DB_COORD{Coord_Ind}.type
                            case 'Rectangular'
                                Offset_vector_B = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            case 'Cylindrical'
                                Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                Offset_vector_B = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                            otherwise
                                fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                        end
                    end

                else

                    switch upper(ELEMENTS{i}.OFFT(3))

                        case 'G'

                            % Система координат анализа ("Global")
                            Coord_ID = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Analysis_CID;

                            if (Coord_ID == 0)
                                Offset_vector_B = Tmp_vector;
                            else
                                Coord_Ind = AT_COORD(Coord_ID);
                                switch DB_COORD{Coord_Ind}.type
                                    case 'Rectangular'
                                        Offset_vector_B = [DB_COORD{Coord_Ind}.e_x, DB_COORD{Coord_Ind}.e_y, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    case 'Cylindrical'
                                        Tmp_vector = [Tmp_vector(1)*cosd(Tmp_vector(2)); Tmp_vector(1)*sind(Tmp_vector(2)); Tmp_vector(3)];
                                        Offset_vector_B = [DB_COORD{Coord_Ind}.e_r, DB_COORD{Coord_Ind}.e_t, DB_COORD{Coord_Ind}.e_z]*Tmp_vector;
                                    otherwise
                                        fprintf (1, '\nТип [%s] системы координат с номером %i не поддерживается в текущей версии программы !\n', DB_COORD{Coord_Ind}.type, Coord_ID);
                                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                        ErrCode = -1;
                                        return;
                                end
                            end

                        case 'O'

                            % Система координат оффсета ("Offset")
                            
                            e_x = DB_NODES{AT_NODES(ELEMENTS{i}.GB)}.Location - DB_NODES{AT_NODES(ELEMENTS{i}.GA)}.Location;
                            
                            ori_vec_norm = norm(e_x);
                            
                            % Дополнительная проверка, которую нельзя выполнить в функции Check_Elements
                            if (ori_vec_norm < Orientation_Vector_zero_tolerance)
                                fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: длина вектора ориентации GA:GB меньше допускаемой величины %e в карточке элемента %i типа %s !\n', Orientation_Vector_zero_tolerance, ELEMENTS{i}.ID, upper(ELEMENTS{i}.card));
                                fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                                ErrCode = -1;
                                return;
                            end
                            
                            e_x = e_x / ori_vec_norm;
                            
                            e_z = cross(e_x, Ori_vector);
                            e_z = e_z / norm(e_z);
                            
                            e_y = cross(e_z, e_x);
                            e_y = e_y / norm(e_y);
                            
                            Offset_vector_B = [e_x, e_y, e_z]*Tmp_vector;
                            
                        otherwise
                            
                            fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.OFFT(3) !\n');
                            fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                            ErrCode = -1;
                            return;

                    end

                end
                
            else
                
                Offset_vector_B = [];
            
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_vector_B_Field_ID, DB_ELEMENTS{i}.ID, Offset_vector_B);
            if (ErrCode < 0)
                return;
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Pinned_DOFs_A_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.PA);
            if (ErrCode < 0)
                return;
            end
            
            DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Pinned_DOFs_B_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.PB);
            if (ErrCode < 0)
                return;
            end
        
        case 'CQUAD4'
            
            DB_ELEMENTS{i}.type = 'Quad';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = size(ELEMENTS{i}.G,1);
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.G;
            
            if (isempty(ELEMENTS{i}.Ori_type))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [1;0]);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                switch ELEMENTS{i}.Ori_type
                    case 'CID'
                        Current_ori_type = 0;
                    case 'Angle'
                        Current_ori_type = 1;
                    otherwise
                        fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.Ori_type !\n');
                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                        ErrCode = -1;
                        return;
                end
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [Current_ori_type; ELEMENTS{i}.THETA_MCID]);
                if (ErrCode < 0)
                    return;
                end

            end
            
            if (isempty(ELEMENTS{i}.ZOFFS))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, 0);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.ZOFFS);
                if (ErrCode < 0)
                    return;
                end
                
            end
            
        case 'CQUAD8'
            
            DB_ELEMENTS{i}.type = 'Quad';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = size(ELEMENTS{i}.G,1);
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.G;
            
            if (isempty(ELEMENTS{i}.Ori_type))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [1;0]);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                switch ELEMENTS{i}.Ori_type
                    case 'CID'
                        Current_ori_type = 0;
                    case 'Angle'
                        Current_ori_type = 1;
                    otherwise
                        fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.Ori_type !\n');
                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                        ErrCode = -1;
                        return;
                end
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [Current_ori_type; ELEMENTS{i}.THETA_MCID]);
                if (ErrCode < 0)
                    return;
                end

            end
            
            if (isempty(ELEMENTS{i}.ZOFFS))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, 0);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.ZOFFS);
                if (ErrCode < 0)
                    return;
                end
                
            end
            
        case 'CTRIA3'
            
            DB_ELEMENTS{i}.type = 'Tria';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = size(ELEMENTS{i}.G,1);
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.G;
            
            if (isempty(ELEMENTS{i}.Ori_type))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [1;0]);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                switch ELEMENTS{i}.Ori_type
                    case 'CID'
                        Current_ori_type = 0;
                    case 'Angle'
                        Current_ori_type = 1;
                    otherwise
                        fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.Ori_type !\n');
                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                        ErrCode = -1;
                        return;
                end
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [Current_ori_type; ELEMENTS{i}.THETA_MCID]);
                if (ErrCode < 0)
                    return;
                end

            end
            
            if (isempty(ELEMENTS{i}.ZOFFS))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, 0);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.ZOFFS);
                if (ErrCode < 0)
                    return;
                end
                
            end
            
        case 'CTRIA6'
            
            DB_ELEMENTS{i}.type = 'Tria';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = size(ELEMENTS{i}.G,1);
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.G;
            
            if (isempty(ELEMENTS{i}.Ori_type))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [1;0]);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                switch ELEMENTS{i}.Ori_type
                    case 'CID'
                        Current_ori_type = 0;
                    case 'Angle'
                        Current_ori_type = 1;
                    otherwise
                        fprintf (1, '\nОшибка функции Create_DB_ELEMENTS: исключение оператора switch по параметру ELEMENTS{i}.Ori_type !\n');
                        fprintf (1, 'Обратитесь к разработчику для решения этого вопроса.\n');
                        ErrCode = -1;
                        return;
                end
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Ori_Field_ID, DB_ELEMENTS{i}.ID, [Current_ori_type; ELEMENTS{i}.THETA_MCID]);
                if (ErrCode < 0)
                    return;
                end

            end
            
            if (isempty(ELEMENTS{i}.ZOFFS))
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, 0);
                if (ErrCode < 0)
                    return;
                end
                
            else
                
                DB_Field_Add_Record(DB_PSETS{AT_PSETS(DB_ELEMENTS{i}.Prop_ID)}.Offset_Field_ID, DB_ELEMENTS{i}.ID, ELEMENTS{i}.ZOFFS);
                if (ErrCode < 0)
                    return;
                end
                
            end
        
        case 'CTETRA'
            
            DB_ELEMENTS{i}.type = 'Tet';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = ELEMENTS{i}.N_nodes;
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.Nodes;
            
        case 'CPENTA'
            
            DB_ELEMENTS{i}.type = 'Wedge';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = ELEMENTS{i}.N_nodes;
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.Nodes;
            
        case 'CHEXA'
            
            DB_ELEMENTS{i}.type = 'Hex';
            DB_ELEMENTS{i}.ID = ELEMENTS{i}.ID;
            DB_ELEMENTS{i}.Prop_ID = ELEMENTS{i}.Prop_ID;
            DB_ELEMENTS{i}.N_nodes = ELEMENTS{i}.N_nodes;
            DB_ELEMENTS{i}.Nodes = ELEMENTS{i}.Nodes;
        
        otherwise
            
            fprintf (1, '\nНеизвестная карточка элемента %i [%s] !\n', ELEMENTS{i}.ID, ELEMENTS{i}.card);
            ErrCode = -1;
            return;
        
    end
    
    if (size(ELEMENTS,1) > Progress_Bar_Elm_Threshold)
        
        % Для вывода прогресса
        Counter = Counter + 1;
        Counter_2 = Counter_2 + 1;
        if (Counter_2 == N_rec_segm)
            Counter_2 = 0;
            Written_count = Written_count + 1;
            if (Written_count < Time_segments)
                fprintf (1, '#');
                pause (Progress_Bar_Delay);
            end
        end
        
    end
    
    
end

if (size(ELEMENTS,1) > Progress_Bar_Elm_Threshold)
    
    % Для вывода прогресса
    if (N_rec_segm == 0)
        for i=1:Time_segments-1
            fprintf (1, '#');
            pause (Progress_Bar_Delay);
        end
    end
    fprintf (1, '# ');
    pause (Progress_Bar_Delay);
    
end


fprintf (1, 'OK!\n');
